'use strict';
const db = uniCloud.database();
const dbCmd = db.command;

/**
 * 多功能增删改查云对象
 */
module.exports = {
  /**
   * 添加数据
   * @param {string} collection 集合名称
   * @param {Object} data 要添加的数据
   * @returns {Promise} 添加结果
   */
  async add(collection, data) {
    if (!collection || typeof collection !== 'string') {
      return {
        code: 400,
        message: '集合名称不能为空且必须为字符串'
      };
    }
    
    if (!data || typeof data !== 'object') {
      return {
        code: 400,
        message: '数据不能为空且必须为对象'
      };
    }
    
    try {
      const res = await db.collection(collection).add(data);
      return {
        code: 200,
        message: '添加成功',
        data: res
      };
    } catch (e) {
      return {
        code: 500,
        message: '添加失败',
        error: e.message
      };
    }
  },
  
  /**
   * 删除数据
   * @param {string} collection 集合名称
   * @param {string} id 要删除的文档ID
   * @returns {Promise} 删除结果
   */
  async remove(collection, id) {
    if (!collection || typeof collection !== 'string') {
      return {
        code: 400,
        message: '集合名称不能为空且必须为字符串'
      };
    }
    
    if (!id || typeof id !== 'string') {
      return {
        code: 400,
        message: '文档ID不能为空且必须为字符串'
      };
    }
    
    try {
      const res = await db.collection(collection).doc(id).remove();
      return {
        code: 200,
        message: '删除成功',
        data: res
      };
    } catch (e) {
      return {
        code: 500,
        message: '删除失败',
        error: e.message
      };
    }
  },
  
  /**
   * 更新数据
   * @param {string} collection 集合名称
   * @param {string} id 要更新的文档ID
   * @param {Object} data 要更新的数据
   * @returns {Promise} 更新结果
   */
  async update(collection, id, data) {
    if (!collection || typeof collection !== 'string') {
      return {
        code: 400,
        message: '集合名称不能为空且必须为字符串'
      };
    }
    
    if (!id || typeof id !== 'string') {
      return {
        code: 400,
        message: '文档ID不能为空且必须为字符串'
      };
    }
    
    if (!data || typeof data !== 'object') {
      return {
        code: 400,
        message: '数据不能为空且必须为对象'
      };
    }
    
    try {
      const res = await db.collection(collection).doc(id).update(data);
      return {
        code: 200,
        message: '更新成功',
        data: res
      };
    } catch (e) {
      return {
        code: 500,
        message: '更新失败',
        error: e.message
      };
    }
  },
  
  /**
   * 查询单条数据
   * @param {string} collection 集合名称
   * @param {string} id 要查询的文档ID
   * @returns {Promise} 查询结果
   */
  async get(collection, id) {
    if (!collection || typeof collection !== 'string') {
      return {
        code: 400,
        message: '集合名称不能为空且必须为字符串'
      };
    }
    
    if (!id || typeof id !== 'string') {
      return {
        code: 400,
        message: '文档ID不能为空且必须为字符串'
      };
    }
    
    try {
      const res = await db.collection(collection).doc(id).get();
      return {
        code: 200,
        message: '查询成功',
        data: res.data[0] || null
      };
    } catch (e) {
      return {
        code: 500,
        message: '查询失败',
        error: e.message
      };
    }
  },
  
  /**
   * 分页查询数据
   * @param {string} collection 集合名称
   * @param {Object} options 查询选项
   * @param {number} options.page 页码
   * @param {number} options.pageSize 每页数量
   * @param {Object} options.where 查询条件
   * @param {string} options.orderBy 排序字段
   * @param {string} options.orderType 排序方式(asc/desc)
   * @returns {Promise} 查询结果
   */
  async list(collection, options = {}) {
    if (!collection || typeof collection !== 'string') {
      return {
        code: 400,
        message: '集合名称不能为空且必须为字符串'
      };
    }
    
    const {
      page = 1,
      pageSize = 10,
      where = {},
      orderBy = 'createTime',
      orderType = 'desc'
    } = options;
    
    try {
      const collectionRef = db.collection(collection);
      let query = collectionRef.where(where);
      
      // 排序
      if (orderBy) {
        query = query.orderBy(orderBy, orderType);
      }
      
      // 分页
      const res = await query.skip((page - 1) * pageSize).limit(pageSize).get();
      
      // 获取总数
      const countRes = await collectionRef.where(where).count();
      
      return {
        code: 200,
        message: '查询成功',
        data: {
          list: res.data,
          total: countRes.total,
          page,
          pageSize,
          totalPages: Math.ceil(countRes.total / pageSize)
        }
      };
    } catch (e) {
      return {
        code: 500,
        message: '查询失败',
        error: e.message
      };
    }
  },
  
  /**
   * 批量删除
   * @param {string} collection 集合名称
   * @param {Array} ids 要删除的文档ID数组
   * @returns {Promise} 删除结果
   */
  async batchRemove(collection, ids) {
    if (!collection || typeof collection !== 'string') {
      return {
        code: 400,
        message: '集合名称不能为空且必须为字符串'
      };
    }
    
    if (!Array.isArray(ids) || ids.length === 0) {
      return {
        code: 400,
        message: '文档ID不能为空且必须为数组'
      };
    }
    
    try {
      const res = await db.collection(collection).where({
        _id: dbCmd.in(ids)
      }).remove();
      
      return {
        code: 200,
        message: '批量删除成功',
        data: res
      };
    } catch (e) {
      return {
        code: 500,
        message: '批量删除失败',
        error: e.message
      };
    }
  },
  
  /**
   * 批量更新
   * @param {string} collection 集合名称
   * @param {Array} ids 要更新的文档ID数组
   * @param {Object} data 要更新的数据
   * @returns {Promise} 更新结果
   */
  async batchUpdate(collection, ids, data) {
    if (!collection || typeof collection !== 'string') {
      return {
        code: 400,
        message: '集合名称不能为空且必须为字符串'
      };
    }
    
    if (!Array.isArray(ids) || ids.length === 0) {
      return {
        code: 400,
        message: '文档ID不能为空且必须为数组'
      };
    }
    
    if (!data || typeof data !== 'object') {
      return {
        code: 400,
        message: '数据不能为空且必须为对象'
      };
    }
    
    try {
      const res = await db.collection(collection).where({
        _id: dbCmd.in(ids)
      }).update(data);
      
      return {
        code: 200,
        message: '批量更新成功',
        data: res
      };
    } catch (e) {
      return {
        code: 500,
        message: '批量更新失败',
        error: e.message
      };
    }
  },

  /**
   * 批量新增数据
   * @param {string} collection 集合名称
   * @param {Array} dataList 要新增的数据数组
   * @returns {Promise} 新增结果
   */
  async batchAdd(collection, dataList) {
    if (!collection || typeof collection !== 'string') {
      return {
        code: 400,
        message: '集合名称不能为空且必须为字符串'
      };
    }
    
    if (!Array.isArray(dataList) || dataList.length === 0) {
      return {
        code: 400,
        message: '数据不能为空且必须为数组'
      };
    }
    
    try {
      // 检查足环号唯一性
      const footRingNumbers = dataList.map(item => 
        [item.foot_ring_number_a, item.foot_ring_number_b, item.foot_ring_number_c, item.foot_ring_number_d].filter(Boolean)
      ).flat();
      
      const existingRecords = await db.collection(collection)
        .where({
          $or: [
            { foot_ring_number_a: db.command.in(footRingNumbers) },
            { foot_ring_number_b: db.command.in(footRingNumbers) },
            { foot_ring_number_c: db.command.in(footRingNumbers) },
            { foot_ring_number_d: db.command.in(footRingNumbers) },
          ]
        })
        .get();
      
      if (existingRecords.data.length > 0) {
        const duplicateNumbers = existingRecords.data.map(record => 
          [record.foot_ring_number_a, record.foot_ring_number_b, record.foot_ring_number_c, record.foot_ring_number_d]
            .filter(num => num && footRingNumbers.includes(num))
        ).flat();
        
        return {
          code: 400,
          message: '足环号已存在，请确保足环号唯一',
          data: {
            duplicateNumbers: [...new Set(duplicateNumbers)] // 去重
          }
        };
      }
      
      const res = await db.collection(collection).add(dataList);
      return {
        code: 200,
        message: '批量新增成功',
        data: res
      };
    } catch (e) {
      return {
        code: 500,
        message: '批量新增失败',
        error: e.message
      };
    }
  },
  
  
  /**
   * 高级搜索
   * @param {string} collection 集合名称
   * @param {Object} options 搜索选项
   * @param {string} options.keyword 关键词
   * @param {Object} options.filters 过滤条件
   * @param {number} options.page 页码
   * @param {number} options.pageSize 每页数量
   * @param {string} options.orderBy 排序字段
   * @param {string} options.orderType 排序方式(asc/desc)
   * @returns {Promise} 搜索结果
   */
  async search(collection, options = {}) {
    if (!collection || typeof collection !== 'string') {
      return {
        code: 400,
        message: '集合名称不能为空且必须为字符串'
      };
    }
    
    const {
      keyword = '',
      filters = {},
      page = 1,
      pageSize = 10,
      orderBy = 'createTime',
      orderType = 'desc'
    } = options;
    
    try {
      const collectionRef = db.collection(collection);
      let query = collectionRef.where(filters);
      
      // 关键词搜索
      if (keyword) {
        const keywordQuery = {};
        // 假设集合中有title和content字段需要搜索
        keywordQuery.$or = [
          { title: new RegExp(keyword, 'i') },
          { content: new RegExp(keyword, 'i') }
        ];
        query = query.where(keywordQuery);
      }
      
      // 排序
      if (orderBy) {
        query = query.orderBy(orderBy, orderType);
      }
      
      // 分页
      const res = await query.skip((page - 1) * pageSize).limit(pageSize).get();
      
      // 获取总数
      const countRes = await query.count();
      
      return {
        code: 200,
        message: '搜索成功',
        data: {
          list: res.data,
          total: countRes.total,
          page,
          pageSize,
          totalPages: Math.ceil(countRes.total / pageSize)
        }
      };
    } catch (e) {
      return {
        code: 500,
        message: '搜索失败',
        error: e.message
      };
    }
  },
  
  /**
   * 关键字搜索
   * @param {string} collection 集合名称
   * @param {string} keyword 关键词
   * @param {Object} options 查询选项
   * @param {number} options.page 页码
   * @param {number} options.pageSize 每页数量
   * @returns {Promise} 搜索结果
   */
  async keywordSearch(collection, keyword, options = {}) {
    if (!collection || typeof collection !== 'string') {
      return {
        code: 400,
        message: '集合名称不能为空且必须为字符串'
      };
    }
    
    if (!keyword || typeof keyword !== 'string') {
      return {
        code: 400,
        message: '关键词不能为空且必须为字符串'
      };
    }
    
    const {
      page = 1,
      pageSize = 10
    } = options;
    
    try {
      const collectionRef = db.collection(collection);
      
      // 创建关键词查询条件
      const keywordQuery = {};
      keywordQuery.$or = [
        { title: new RegExp(keyword, 'i') },
        { content: new RegExp(keyword, 'i') }
      ];
      
      // 执行查询
      const query = collectionRef.where(keywordQuery);
      const res = await query.skip((page - 1) * pageSize).limit(pageSize).get();
      
      // 获取总数
      const countRes = await query.count();
      
      return {
        code: 200,
        message: '搜索成功',
        data: {
          list: res.data,
          total: countRes.total,
          page,
          pageSize,
          totalPages: Math.ceil(countRes.total / pageSize)
        }
      };
    } catch (e) {
      return {
        code: 500,
        message: '搜索失败',
        error: e.message
      };
    }
  }
};